require('dotenv').config();
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const compression = require('compression');
const rateLimit = require('express-rate-limit');
const path = require('path');

// 导入数据库模型
const db = require('./models');
const logger = require('./utils/logger');

// 导入路由
const categoryRoutes = require('./routes/categories');
const lessonRoutes = require('./routes/lessons');
const tagRoutes = require('./routes/tags');
const codeExampleRoutes = require('./routes/codeExamples');
const uploadRoutes = require('./routes/upload');

const app = express();
const PORT = process.env.PORT || 3001;
const API_PREFIX = process.env.API_PREFIX || '/api';

// 安全中间件
app.use(helmet());

// CORS 配置
app.use(cors({
  origin: [
    process.env.FRONTEND_URL || 'http://localhost:5173',
    'http://localhost:3000', // 备用前端端口
    'http://127.0.0.1:5173'  // 本地IP访问
  ],
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
  exposedHeaders: ['X-Total-Count'] // 暴露分页信息头部
}));

// 请求限制
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 分钟
  max: 100, // 限制每个 IP 每15分钟最多100个请求
  message: {
    error: '请求过于频繁，请稍后再试'
  }
});
app.use(limiter);

// 压缩响应
app.use(compression());

// 日志中间件
if (process.env.NODE_ENV === 'development') {
  app.use(morgan('dev'));
} else {
  app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }));
}

// 解析请求体
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// 静态文件服务
app.use('/uploads', express.static(path.join(__dirname, 'uploads')));

// 添加根路径处理
app.get('/', (req, res) => {
  res.json({
    message: 'Cursor 学习平台 API 服务',
    version: '1.0.0',
    endpoints: {
      health: '/health',
      api: API_PREFIX,
      categories: `${API_PREFIX}/categories`,
      lessons: `${API_PREFIX}/lessons`,
      tags: `${API_PREFIX}/tags`
    }
  });
});

// 健康检查端点
app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    timestamp: new Date().toISOString(),
    service: 'cursor-learning-api'
  });
});

// API 路由
app.use(`${API_PREFIX}/categories`, categoryRoutes);
app.use(`${API_PREFIX}/lessons`, lessonRoutes);
app.use(`${API_PREFIX}/tags`, tagRoutes);
app.use(`${API_PREFIX}/codeExamples`, codeExampleRoutes);
app.use(`${API_PREFIX}/upload`, uploadRoutes);

// 404 处理
app.use((req, res) => {
  res.status(404).json({
    error: '请求的资源不存在',
    path: req.path
  });
});

// 全局错误处理
app.use((err, req, res, next) => {
  logger.error('服务器错误:', err);
  
  // Sequelize 验证错误
  if (err.name === 'SequelizeValidationError') {
    return res.status(400).json({
      error: '数据验证失败',
      details: err.errors.map(e => ({
        field: e.path,
        message: e.message
      }))
    });
  }
  
  // Sequelize 唯一约束错误
  if (err.name === 'SequelizeUniqueConstraintError') {
    return res.status(409).json({
      error: '数据已存在',
      field: err.errors[0]?.path
    });
  }
  
  // JWT 错误
  if (err.name === 'JsonWebTokenError') {
    return res.status(401).json({
      error: '无效的访问令牌'
    });
  }
  
  // 默认错误响应
  const status = err.status || 500;
  const message = process.env.NODE_ENV === 'production' 
    ? '服务器内部错误' 
    : err.message;
    
  res.status(status).json({
    error: message,
    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
  });
});

// 数据库连接和服务器启动
async function startServer() {
  try {
    // 测试数据库连接
    await db.sequelize.authenticate();
    logger.info('数据库连接成功');
    
    // 同步数据库表（开发环境）
    if (process.env.NODE_ENV === 'development') {
      //await db.sequelize.sync({ alter: true });
      logger.info('数据库表同步完成');
    }
    
    // 启动服务器
    app.listen(PORT, () => {
      logger.info(`服务器运行在端口 ${PORT}`);
      logger.info(`API 访问地址: http://localhost:${PORT}${API_PREFIX}`);
    });
    
  } catch (error) {
    logger.error('服务器启动失败:', error);
    process.exit(1);
  }
}

startServer();

module.exports = app; 